package com.ruoyi.utils.login;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

/**
 * @Description: 日期工具类
 * @author: LXH
 * @Date: 2019/7/5 16:32
 */
public class DateUtil {

	public static final String DATE_PATTERN = "yyyy-MM-dd";

	public static final String YYYY = "yyyy";

	public static final String TIME_PATTERN = "hh:mm:ss";

	public static final String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

	public static final String yyyyMMddHHmmss = "yyyyMMddHHmmss";


	public static String getyyyy() {
		Date date = new Date(); // 新建此时的的系统时间
		SimpleDateFormat format = new SimpleDateFormat("yyyy");
//		String str = format.format(date); // 转为字符串
		return format.format(date);
	}


	private DateUtil() throws Exception {
		throw new Exception("不允许实例化");
	}

	/**
	 * 获取当前时间，日期格式如：2017-07-28 09:57:43
	 *
	 * @return {@link Date()} 返回当前时间
	 */
	public static String getNow() {
		Date date = new Date(); // 新建此时的的系统时间
		SimpleDateFormat format = new SimpleDateFormat(DATE_TIME_PATTERN);
//		String str = format.format(date); // 转为字符串
		return format.format(date);
	}

	/**
	 * 获取当前时间，日期格式如：2017-07-28 09:57:43
	 *
	 * @return {@link Date()} 返回当前时间
	 */
	public static String getTime() {
		Date date = new Date(); // 新建此时的的系统时间
		SimpleDateFormat format = new SimpleDateFormat(yyyyMMddHHmmss);
		return format.format(date);
	}

	/**
	 * 获取当前时间，日期格式如：17-07-28 09:57:43
	 *
	 * @return {@link Date()} 返回当前时间
	 */
	public static String getTime1() {
		Date date = new Date(); // 新建此时的的系统时间
		SimpleDateFormat format = new SimpleDateFormat("yyMMddHHmmss");
		return format.format(date);
	}

	/**
	 * 获取当前时间，日期格式如：2017-07-28
	 *
	 * @return {@link Date()} 返回当前时间
	 */
	public static String getNowS() {
		Date date = new Date(); // 新建此时的的系统时间
		SimpleDateFormat format = new SimpleDateFormat(DATE_PATTERN);
		String str = format.format(date); // 转为字符串
		return str;
	}

	/**
	 * 根据指定格式获取当前时间
	 *
	 * @return {@link Date()} 返回当前时间0
	 */
	public static String getNow(String pattern) {
		Date date = new Date(); // 新建此时的的系统时间
		SimpleDateFormat format = new SimpleDateFormat(pattern);
		String str = format.format(date); // 转为字符串
		return str;
	}


	/**
	 * String类型转Date类型
	 * @param str 日期格式的字符串形式，如：2017-07-28 09:57:43
	 * @return {@link Date()} Date类型的返回值
	 */
	public static Date str2Date(String str) {
		try {
			SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			return format.parse(str);
		} catch (ParseException e) {
			return null;
		}
	}


		/**
		 * 新增datetime时间
		 * @return {@link Date()} Date类型的返回值
		 */
		public static Date getDate() {
			Date date=new Date();     //先获取一个Date对象
			DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");   //创建一个格式化日期对象
			String punchTime = simpleDateFormat.format(date);//格式化后的时间
			return DateUtil.str2Date(punchTime);
		}


	/**
	 * Date类型转String类型
	 *
	 * @param date 传入一个Date类型的参数
	 * @return {@link String} 日期格式的字符串形式，如：2017-07-28 09:57:43
	 */
	public static String date2Str(Date date) {
		try {
			SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			return format.format(date);
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * Date类型转String类型
	 *
	 * @param date 传入一个Date类型的参数
	 * @return {@link String} 日期格式的字符串形式，如：2017-07-28 09:57:43
	 */
	public static String date2Str(Date date, String pattern) {
		try {
			SimpleDateFormat format = new SimpleDateFormat(pattern);
			return format.format(date);
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * 获取下一小时的时间，日期格式如：2017-07-28 09:57:43
	 *
	 * @return 获取下一小时的时间，日期格式如：2017-07-28 09:57:43
	 */
	public static String getNextHour() {
		return date2Str(new Date(str2Date(getNow()).getTime() + 1 * 1000 * 60 * 60));
	}

	/**
	 * 获取下一小时的时间，日期格式如：2017-07-28 09:57:43
	 *
	 * @return 获取下一小时的时间，日期格式如：2017-07-28 09:57:43
	 */
	public static String getNextHour(String now) {
		return date2Str(new Date(str2Date(now).getTime() + 1 * 1000 * 60 * 60));
	}

	/**
	 * 把一个日期转换为指定的格式，formater为空则格式为：yyyy-MM-dd HH:mm:ss
	 *
	 * @param strDate {@link String} 源字符日期
	 * @param formater {@link String} 日期格式，如：yyyy-MM-dd、yyyy年MM月dd日等
	 * @return
	 */
	public static Date str2Date(String strDate, String formater) {
		if (strDate == null) {
			return null;
		}
		if (formater == null) {
			formater = "yyyy-MM-dd HH:mm:ss";
		}
		SimpleDateFormat df = new SimpleDateFormat(formater);
		Date date = new Date();
		try {
			date = df.parse(strDate);
		} catch (ParseException pe) {
			pe.getStackTrace();
		}
		return date;
	}

	/**
	 * 获取第二天时间，日期格式如：2017-07-28 09:57:43
	 *
	 * @return {@link Date()} 返回当前时间0
	 */
	public static String getNextDay() {
		Date date = new Date();// 新建此时的的系统时间
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.DAY_OF_MONTH, +1);// +1今天的时间加一天
		date = calendar.getTime();

		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String str = format.format(date); // 转为字符串
		System.out.println("第2天时间:" + str);
		return str;
	}

	/**
	 * 返回两时间的相差天数
	 *
	 * @param d1
	 * @param d2
	 * @return
	 */
	public static int getDayNumBetween2Date(Date d1, Date d2) {

		if (isEqualsInYMD(d1, d2)) {
			return 0;
		}

		long l = d2.getTime() - d1.getTime();
		int day = (int) (l / (24 * 60 * 60 * 1000));
		if (day < 0) {
			day = (-day);
		}

		int m = (int) (l % (24 * 60 * 60 * 1000));
		Calendar c = Calendar.getInstance();
		if (d1.compareTo(d2) <= 0) {
			c.setTime(d1);
			c.add(Calendar.MILLISECOND, m);
			if (isEqualsInYMD(d1, c.getTime())) {
				return day;
			} else {
				return day + 1;
			}
		} else {
			c.setTime(d2);
			c.add(Calendar.MILLISECOND, m);
			if (isEqualsInYMD(d2, c.getTime())) {
				return day;
			} else {
				return day + 1;
			}
		}

	}

	/**
	 * 两个时间是否是 同年 同月 同日 如果是，则返回true，否则返回false
	 *
	 * @param d1
	 * @param d2
	 * @return
	 */
	public static boolean isEqualsInYMD(Date d1, Date d2) {

		Calendar c = Calendar.getInstance();

		c.setTime(d1);
		int year1 = c.get(Calendar.YEAR);
		int dayOfYear1 = c.get(Calendar.DAY_OF_YEAR);

		c.setTime(d2);
		int year2 = c.get(Calendar.YEAR);
		int dayOfYear2 = c.get(Calendar.DAY_OF_YEAR);

		if (year1 != year2) {
			return false;
		}
		if (dayOfYear1 != dayOfYear2) {
			return false;
		}

		return true;
	}

	/**
	 * 计算两个时间之间相差的时间数，例：0天0时0分钟
	 * @param beginDate
	 * @param endDate
	 * @return
	 */
	public static String getDatePoor(Date beginDate, Date endDate) {

		long nd = 1000 * 24 * 60 * 60;
		long nh = 1000 * 60 * 60;
		long nm = 1000 * 60;
		// long ns = 1000;
		// 获得两个时间的毫秒时间差异
		long diff = beginDate.getTime() - endDate.getTime();
		if(diff < 0) {
			diff = -diff;
		}
		// 计算差多少天
		long day = diff / nd;
		// 计算差多少小时
		long hour = diff % nd / nh;
		// 计算差多少分钟
		long min = diff % nd % nh / nm;
		// 计算差多少秒//输出结果
		// long sec = diff % nd % nh % nm / ns;
		return day + "天" + hour + "小时" + min + "分钟";
	}

	/**
	 * 计算两个日期之间相差的月份
	 *
	 * @param date1
	 * @param date2
	 * @param pattern
	 * @return
	 */
	public static int getMonth(String date1, String date2, String pattern) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat(pattern);
			String str1 = date1;
			String str2 = date2;
			Calendar bef = Calendar.getInstance();
			Calendar aft = Calendar.getInstance();
			bef.setTime(sdf.parse(str1));
			aft.setTime(sdf.parse(str2));
			int result = aft.get(Calendar.MONTH) - bef.get(Calendar.MONTH);
			int month = (aft.get(Calendar.YEAR) - bef.get(Calendar.YEAR)) * 12;
			return Math.abs(month + result);
		} catch(Exception e) {
			e.printStackTrace();
			return -1;
		}
	}

	/**
	 * 计算两个日期之间相差的时间
	 *
	 * @param day1 {@link Date} Date类型的日期对象
	 * @param day2 {@link Date} Date类型的日期对象
	 * @return {@link String} 精确到秒的时间差
	 */
	public static String calculateTimes(Date day1, Date day2) {
		long diff = Math.abs(day1.getTime() - day2.getTime());
		int dayNs = 1000 * 60 * 60 * 24;
		int hourNs = 1000 * 60 * 60;
		int minuteNs = 1000 * 60;    //分种
		int secondNs = 1000;

		long day = diff / dayNs;
		long hour = (diff % dayNs) / (hourNs);
		long minute = (diff % dayNs % hourNs) / minuteNs;
		long second = (diff % dayNs % hourNs % minuteNs) / secondNs;


		return day + "天" + hour + "小时" + minute + "分钟";
	}

	//计算两个日期之间相差的毫秒
	public static int haomiao(Date day1, Date day2) {
		long diff = Math.abs(day1.getTime() - day2.getTime());
		int v=(int)diff/1000/60;
		System.out.println("V"+v);
		return v;
	}

	//毫秒转小时、分、秒
	public static String haomiaos(int day1) {
		return format(day1);
	}


	//时间比较
	public static boolean judgmentDate(String date1, String date2,String shuju) throws Exception {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
		Date start = sdf.parse(date1);
		Date end = sdf.parse(date2);
		long cha = end.getTime() - start.getTime();
		if (cha < 0) {
			return false;
		}
		double result = cha * 1.0 / (1000 * 60 * 60);
		if (result <= Integer.valueOf(shuju)) {
			return true;
		} else {
			return false;
		}
	}

	//有效期还剩
	public static double judgmentDate1(String date1, String date2,String hourNs) throws Exception {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
		Date start = sdf.parse(date1);
		Date end = sdf.parse(date2);
		long cha = start.getTime() - end.getTime();   //当前时间毫秒-开票时间毫秒

		double sj=Double.valueOf(hourNs);    //票有效期时长
		try {
			double result = cha * 1.0 / (1000*60);   //毫秒转分钟
			double time= (sj*60);       //小时转分钟-分钟
			sj=time-result;        //分钟减分钟
			System.out.println("票已过去时效："+result);

			System.out.println("票有效期还剩："+sj);
		}catch (Exception e){
			e.getMessage();
		}
		return sj;
	}

	//抵扣后的时间
	public static double judgmentDate2(String date1, String date2) throws Exception {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
		Date start = sdf.parse(date1);
		Date end = sdf.parse(date2);
		long cha = start.getTime() - end.getTime();
		double result=0.0;
		try {
			result = cha * 1.0 / (1000*60);
//			System.out.println("抵扣后的停留时长："+result);
		}catch (Exception e){
			e.getMessage();
		}
		return result;
	}



	/**
	 * 新增int类型时间
	 */
	public static String getInteger() {
		long timeStamp = System.currentTimeMillis();  //获取当前时间戳,也可以是你自已给的一个随机的或是别人给你的时间戳(一定是long型的数据)
		String s3 = Long.toString(timeStamp).substring(0,10);
		return s3;
	}


	/**
	 * int转date类型
	 */
//	public static String getD(String date) {
//		SimpleDateFormat format = new SimpleDateFormat(DATE_TIME_PATTERN);
////		 int seconds=1531126880;//这是你数据库提出的数据
//		long millions=new Long(date).longValue()*1000;
////	      System.out.println("QQQQ："+format.format(millions));
//		return format.format(millions);
//	}


	/**
	 * int转date类型
	 */
	public static String getD(int date) {
		SimpleDateFormat format = new SimpleDateFormat(DATE_TIME_PATTERN);
//		 int seconds=1531126880;//这是你数据库提出的数据
		long millions=new Long(date).longValue()*1000;
//	      System.out.println("QQQQ："+format.format(millions));
		return format.format(millions);
	}

	/**
	 * @param args
	 * @throws ParseException
	 */
	public static void main(String[] args) throws ParseException ,Exception{
		try {
			// 示例BCD字符串，没有空格
			String bcdString = "20200417115037FF";
			// 转换BCD字符串为Date对象
			Date date = bcdStringToDate(bcdString);
			// 打印结果
			System.out.println("Date: " + date);
		} catch (ParseException e) {
			System.out.println("Error parsing date: " + e.getMessage());
		}
	}


	private static String getString(int t){
		String m="";
		if(t>0){
			if(t<10){
				m="0"+t;
			}else{
				m=t+"";
			}
		}else{
			m="00";
		}
		return m;
	}


	public static String format(int t){
		if(t<60000){
			return (t % 60000 )/1000+"秒";
		}else if((t>=60000)&&(t<3600000)){
			return getString((t % 3600000)/60000)+":"+getString((t % 60000 )/1000);
		}else {
			return getString(t / 3600000)+":"+getString((t % 3600000)/60000)+":"+getString((t % 60000 )/1000);
		}
	}

	//循环符合的日期格式
	public static String dd(String str){
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  //全部统一转存格式
//        str=str.replaceAll(" ","");
		if(str.contains(".")) {
			str=str.replaceAll(".",":");    //获取的时间被扫描到的.则转换为：
		}
		if(str.contains("/")) {
			str=str.replaceAll("/","");   //获取的时间被扫描到的/则转换为-
		}
		if(str.contains("-")) {
			str=str.replaceAll("-","");   //获取的时间被扫描到的/则转换为-
		}
		//循环合法日期格式
		String[] dateformatstr = new String[]{
				"HH:mmyyyyMMdd",
				"HHmmyyyyMMdd",
//                "HHmm yyyyMMdd",       //电影票
//				"HH:mm yyyyMMdd",       //电影票
				"yyyyMMddHH:mm",
				"yyyyMMddHHmm",
//                "yyyyMMdd HHmm",      //步步高
//                "yyyy/MM/ddHH:mm:ss",
//                "yyyy/MM/dd HH:mm:ss", //维也纳
//                "yyyy-MM-dd HH:mm:ss",
//				"yyyy-MM-ddHH:mm:ss",
				"yyyyMMddHH:mm:ss",
				"yyyyMMddHHmmss"
		};//阳光瑞城
		String DDD = "";
		for (String format : dateformatstr) {
			try {
				SimpleDateFormat sdf1 = new SimpleDateFormat(format);
				DDD = sdf.format(sdf1.parse(str));   //去除所有空格符
				System.out.println(DDD);
				return DDD;
			} catch (ParseException e) {
				continue;
			}
		}
		if(DDD==""){
			System.out.println("该票时间模糊已不能使用！");
		}
		return DDD;
	}

	// 将没有空格的BCD编码字符串转换为Date对象
	public static Date bcdStringToDate(String bcdString) throws ParseException {
		// 调用已有的bcdStringToDateTime方法将BCD字符串转换为日期时间字符串
		String dateTimeStr = bcdStringToDateTime(bcdString);
		System.out.println("dateTimeStr=" + dateTimeStr);

		// 使用SimpleDateFormat来解析日期时间字符串
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

		// 将字符串解析为Date对象并返回
		return sdf.parse(dateTimeStr);
	}

	// 将没有空格的BCD编码字符串转换为日期时间字符串
	public static String bcdStringToDateTime(String bcdString) {
		// 假设bcdString格式是 "20200417115037FF"，其中最后的"FF"为结束符

		// 构建日期时间字符串
		StringBuilder dateTime = new StringBuilder();

		// 处理年份
		dateTime.append(bcdString.substring(0, 4)).append("-");
		// 处理月份
		dateTime.append(bcdString.substring(4, 6)).append("-");
		// 处理日
		dateTime.append(bcdString.substring(6, 8)).append(" ");
		// 处理小时
		dateTime.append(bcdString.substring(8, 10)).append(":");
		// 处理分钟
		dateTime.append(bcdString.substring(10, 12)).append(":");
		// 处理秒
		dateTime.append(bcdString.substring(12, 14));

		return dateTime.toString();
	}

	// 将Date转换为BCD编码字符串
	public static String dateToBCDString(Date date) {
		// 使用SimpleDateFormat格式化日期为YYYYMMDDHHMMSS
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
		String formattedDate = sdf.format(date);

		// 构建BCD码字符串
		StringBuilder bcdStringBuilder = new StringBuilder();

		// 将格式化后的日期字符串转换为BCD码字符串
		for (int i = 0; i < formattedDate.length(); i += 2) {
			// 每两位数字转换为一个BCD码
			String bcdPart = formattedDate.substring(i, i + 2);
			bcdStringBuilder.append(bcdPart);
			if (i < formattedDate.length() - 2) {
				bcdStringBuilder.append(" ");
			}
		}

		// 添加结束符FF
		bcdStringBuilder.append(" FF");

		return bcdStringBuilder.toString();
	}

	public static boolean isMoreThan30SecondsAgo(Date date) {
		// 当前时间
		Date now = new Date();

		// 计算两个时间之间的差值（毫秒）
		long diff = now.getTime() - date.getTime();

		// 检查时间差是否大于30秒（30秒 = 30,000毫秒）
		return diff > 30000;
	}
}
